Decoding method for convolutionally coded signal

ABSTRACT

A decoding method for a convolutionally coded signal is provided. The convolutionally coded signal includes a trellis. The decoding method includes determining a plurality of first sub-trellises from the trellis, decoding the first sub-trellises, determining a plurality of second sub-trellises from the trellis, boundaries of the second sub-trellises being different from boundaries of the first sub-trellises, and decoding the second sub-trellises.

This application claims the benefit of Taiwan application Serial No. 104100915, filed Jan. 12, 2015, the subject matter of which is incorporated herein by reference.

BACKGROUND OF THE INVENTION

Field of the Invention

The invention relates in general to a communication system, and more particularly to a soft output decoder for a receiver of convolutional coding communication.

Description of the Related Art

In the process of data transmission of a digital communication system, incorrect messages may be received at a receiver end frequently due to unpredictable interference. Without increasing the transmission power, channel coding, although effectively reduces the error rate, poses a setback of occupying the transmission bandwidth. In view of the increasing demand of data transmission and storage systems of the public, not only the transmission rate will get faster but also the quality of service (QoS) will get higher in the future. As channel coding ensures that an error of the transmission bit is controlled within a certain range, channel coding is a critical consideration in the system design.

Convolutional coding is often used in channel coding to prevent a receiver from receiving incorrect messages. At a transmitting end, a code vector or an information block transmitted may be described by a trellis diagram. The complexity of a trellis diagram is determined by a constraint length of an encoder. Although the operation complexity gets higher as the length of the constraint length gets longer, such coding relatively provides better robustness.

At a receiving end, a soft-decision coder may be adopted to identify a maximum likelihood code vector through a Viterbi algorithm and trellis architecture to perform decoding. However, the operation complexity of a the Viterbi algorithm exponentially increases as the constraint length gets longer. In other words, compared to convolutional coding having a longer constraint length, a Viterbi decoder may require a substantial amount of memory and consume significant power to process the operation.

Turbo coding is proven to render better performance than common coding technologies. A turbo code is formed from processing two or more convolutional codes by a turbo interleaver. To decode turbo codes, convolutional codes are individually decoded by a soft-decision decoder using an iteration approach. A soft-decision decoder decodes a convolutional code to provide extrinsic information, which allows the soft-decision decoder to provide a more accurate result when the soft-decision decoder decodes another convolutional code. In the prior art, soft-decision decoding may adopt a maximum a posterior (MAP) algorithm or a soft output Viterbi algorithm (SOVA), both of which requiring forward recursion and backward recursion for decoding to determine the soft output of one information block. In general, in an environmental with a lower signal-to-noise ratio (SNR), turbo codes render better performance than other convolutional codes.

One type of decoder that directly implements the MAP algorithm performs forward recursion on a trellis of one entire information block, and then performs backward recursion. However, such decoding method not only requires a large amount of memory space but also leads to a severe communication latency, and is not a practically feasible approach.

In the prior art, window technologies are introduced to reduce the required memory space by means of an additional operation amount. That is, the operation amount is trade-off with the memory space. In simple, in window technologies, a code block is divided into a plurality of sub-trellises using a window of a certain size, and only one sub-trellis is decoded each time. As only one sub-trellis is computed, the demand on memory space is smaller. However, window technologies need additional training operations in order to allow the state metric of two boundaries of each sub-trellis to be sufficiently representative.

SUMMARY OF THE INVENTION

A decoding method for a convolutionally coded signal is provided according to an embodiment of the present invention. The convolutionally coded signal includes a trellis. The decoding method includes: determining a plurality of first sub-trellises from the trellis, and determining a predetermined step from each of the first sub-trellises; decoding the first sub-trellises to generate a plurality of state metrics; storing a plurality of state metrics prior and subsequent to the predetermined steps as a first record; determining a plurality of second sub-trellises from the trellis; and decoding the second sub-trellises by utilizing the first record as an initial condition of the second sub-trellises.

A decoding method for a convolutionally coded signal is provided according to another embodiment of the present invention. The convolutionally coded signal includes a trellis. The decoding method includes: determining a plurality of sub-trellises from the trellis; decoding the first sub-trellises; determining a plurality of second sub-trellises from the trellis, boundaries of the second sub-trellises being different from boundaries of the first sub-trellises; and decoding the second sub-trellises.

The above and other aspects of the invention will become better understood with regard to the following detailed description of the preferred but non-limiting embodiments. The following description is made with reference to the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a trellis;

FIG. 2 shows a turbo encoder and decoder;

FIG. 3 shows a decoding process;

FIG. 4 shows a window technology;

FIG. 5 shows a window decoding technology;

FIG. 6 shows window decoding adopted according to an embodiment of the present invention; and

FIG. 7 shows a decoding method according to an embodiment of the present invention.

DETAILED DESCRIPTION OF THE INVENTION

The present invention is capable of improving window technologies. In addition to eliminating the additional training operations of the prior art, the embodiments of the present invention are also capable of reducing the demand on memory space.

In one embodiment of the present invention, a turbo decoder divides a trellis into a plurality of same-sized sub-trellises in each iteration loop. The sub-trellises have the same sub-trellis length. The turbo decoder then decodes all of the sub-trellises in a parallel manner. Boundaries of old sub-trellises in a previous iteration loop are different from boundaries of new sub-trellises in a current iteration loop. From perspectives of a trellis, new sub-trellises are results of levelly shifting old sub-trellises, and the amount of the level shifting is not greater than the length of the sub-trellises.

To decode a sub-trellis, in one embodiment of the present invention, without involving additional training operation in the prior art, forward recursion and backward recursion are performed on the sub-trellis. In one sub-trellis, a forward state metric of a starting step of a sub-trellis needed in the forward recursion and a backward state metric of an ending step of a sub-trellis needed in the backward recursion are commonly referred to as stakes in the disclosure of the application. A stake is an initial condition needed when a sub-trellis is decoded. In one embodiment, the current stake of a sub-trellis is adopted directly from a state metric generated from performing forward recursion and backward recursion of a corresponding step of a previous iteration loop. For example, assume that, for a sub-trellis of a current iteration loop, the starting step is k+1, the ending step is k+L, and the window length is L. The stake of the trellis is the forward state metric α_(k+1)(n) and the backward state metric β_(k+1)(n), where n=0 to N−1. When this sub-trellis is decoded, the stake of this sub-trellis is set as the forward state metric α_(k+1)(n) calculated in the forward recursion of the previous iteration loop, where n=0 to N−1, and the backward state metric β_(k+1)(n) calculated in the backward recursion of the previous iteration loop, where n=0 to N−1.

The above decoding method does not involve any additional training operation. In other words, the current stake of the sub-trellis has already undergone a training operation in the forward and backward recursions of the previous loop, and thus has a certain level of reliability.

In general, convolutional codes and turbo codes may be represented by a trellis, as shown in FIG. 1. The trellis in FIG. 1 includes 13 steps, each having four possible states to represent that the constraint length of an encoder is 2. In other words, block codes having a block length of 12 are obtained from the trellis in FIG. 1. For illustration purposes, in the description below, k represents a block code length, which represents the number of steps that one block code includes. As known in the prior art, a MAP decoder adopts forward recursion and backward recursion on a trellis to generate soft output. Based on received information, a MAP decoder minimizes the bit error probability after the decoding process.

In FIG. 2, the left half shows a turbo encoder, and the right half shows a turbo decoder. A turbo encoder is generally formed by two parallel concatenated recursive systematic convolutional encoders RSC 12 and RSC 14, which are connected by an interleaver INT 16 in between. According to a block code X, the recursive systematic convolutional encoder RSC 12 generates a string of parity bits x_(k) ^(p1) that are in overall referred to as a parity code X^(p1), where k=0 to K−1. Similarly, the recursive systematic convolutional encoder RSC 14 generates a parity code X^(p2) according to an interleaved block code X. The block code X is also referred as a systematic block code X^(s). Bits in the systematic block code X^(s), the parity code X^(p1) and the parity code X^(p2) may be interleavingly connected and be outputted to a communication channel through a multiplexer. To increase the code rate, a part of parity bits may be omitted and not outputted. For example, only a part of the parity bits x_(k) ^(p1) and x_(k) ^(p2) of the same step are outputted to a communication channel, such that the turbo encoder in FIG. 2 may have a higher code rate.

The turbo encoder in FIG. 2 calculates the reliability of the received information, and represents the reliability in form of log-likelihood ratios (LLRs). Each LLR represents the probability of one corresponding bit being 0 and 1. Compared to the systematic block code X^(s), the parity code X^(p1) and the parity code X^(p2), the turbo decoder generates systematic information Y^(s), parity information Y^(p1) and parity information Y^(p2). For example, the systematic information Y^(s) is formed by a string of LLRs y_(k) ^(s), and the parity information Y_(p) ¹ is formed by a string of LLRs y_(k) ^(p1), where k=0 to K−1. The turbo decoder in FIG. 2 includes interleavers INT 20 and 24, soft-input-soft-output SISO 20 and 22, and a de-interleaver 26. Operations and iteration details of these elements substantially follow a Bahl, Cocke, Jelinek and Raviv (BCJR) algorithm, also referred to as a MAP algorithm. According to the systematic information Y^(s) and the parity information Y^(p1) as well as a priori information L_(a1), the SISO 20 calculates soft output (usually representing the maximum posteriori probability by an LLR), which is referred to as extrinsic information L_(e1). After an interleaving process, the extrinsic information L_(e1) becomes a priori information L_(a2). The SISO 22 calculates extrinsic information L_(e2) according to the interleaved systematic information Y^(s), the parity information Y^(p2) and the a priori information L_(a2). The extrinsic information L_(e2) is processed by an interleaving process and becomes the a priori information L_(a1) that is then fed back to the SISO 20. The process having been performed once by the SISO 20 or 22 is referred to as half-iteration, and the computation process having been performed once by the SISO 20 or 22 is referred to as one iteration. In general, such iteration loop is repeated for a fixed number of times, or is repeated until the number of changing symbols in the extrinsic information L_(e1) or L_(e2) in the iteration loop is as small as a predetermined level.

Under the condition that the foregoing MAP algorithm calculates a received message Y, the probability of the message bit being digital 1 or 0 at a step k, or referred to as a posteriori log-likelihood ratio L(uk|Y), is defined as below.

${L\left( {u_{k}❘Y} \right)} = {\ln\frac{P\left( {u_{k} = {{+ 1}❘Y}} \right)}{P\left( {u_{k} = {{- 1}❘Y}} \right)}}$

The MAP algorithm calculates L(uk|Y) of each step k through forward and backward recursive operations on the trellis. L(uk|Y) is organized and represented as:

$\begin{matrix} {{L\left( {u_{k}❘Y} \right)} = {\ln\frac{\sum\limits_{{{({n,m})} \in u_{k}} = 1}\;{{\alpha_{k - 1}(n)}*{\gamma_{k}\left( {n,m} \right)}*{\beta_{k}(m)}}}{\sum\limits_{{{({n,m})} \in u_{k}} = {- 1}}\;{{\alpha_{k - 1}(n)}*{\gamma_{k}\left( {n,m} \right)}*{\beta_{k}(m)}}}}} & (1) \end{matrix}$

In equation (1), the branch metric r_(k)(n,m) represents the probability of becoming a state m at the step k under conditions that the state is n at the step k−1 and the received message is Y, the forward state metric α_(k−1)(n) represents the probability that the state stays n from the step 0 to the step k−1 under a condition that the received message is Y, the backward state metric β_(k)(m) represents the probability that the state stays m from the step K−1 to the step k under a condition that the received message is Y. The alphabet zigma (Σ) of the numerator refers to a calculated total of all branches that possibly generate u_(k)=1. Similarly, the alphabet zigma (Σ) of the denominator refers to a calculated total of all branches that possibly generate u_(k)=−1. As known in the prior art, the forward state metric α_(k)(m) and the backward state metric β_(k)(m) may be respectively represented as:

$\begin{matrix} {{\alpha_{k}(m)} = {\sum\limits_{n = 1}^{M}\;{{\alpha_{k - 1}(n)}*{\gamma_{k}\left( {n,m} \right)}}}} & (2) \\ {{\beta_{k}(m)} = {\sum\limits_{n = 1}^{M}\;{{\beta_{k + 1}(m)}*{\gamma_{k + 1}\left( {n,m} \right)}}}} & (3) \end{matrix}$

It is known from equation (2) that, to calculate the forward state metric α_(k)(m), the forward state metric α prior to the step k needs to be first learned; it is known from equation (3) that, to calculate the backward state metric β_(k)(m), the backward state metric β subsequent to the step k needs to be first learned. Thus, the forward state metric α_(k)(m) and the backward state metric β_(k)(m) are generally calculated and obtained through iteration, with however the directions of the iteration being opposite.

In equation (1), all α_(k−1) and β_(k) are required for the calculation of L(u_(k)|Y). In an operation for realizing equation (1), the branch metric r on each branch of the trellis, and the state metric (including the forward state metric α and the backward state metric β) of each state, are first calculated and stored into a memory, and the required α, β and r are then retrieved from the memory to calculate L(u_(k)|Y). However, with such method, forward recursion and backward recursion need to undergo through all of the K number of steps of the entire trellis before any L(u_(k)|Y) can be outputted. In FIG. 3, it is depicted that, all branch metrics r_(k)(n,m) are first calculated, all forward state metrics α and then all backward state metrics β calculated, and L(u_(k)|Y) is eventually obtained. For a large block code length K, such operation method may produce a substantial output latency, and may thus be unpractical.

FIG. 4 shows a type of window technology capable of reducing the issue of output latency. For example, the window technology divides a trellis 60 into a plurality of same-sized sub-trellises 62 ₁ to 62 ₄ by a window having a predetermined size, and performs forward recursion and backward recursion on each sub-trellis to calculate α, β and r, and then L(u_(k)|Y) for each step k. However, when the window technologies is applied, the stake, i.e., the forward state metric of a starting step in the sub-trellis and the backward state metric of an ending step in the sub-trellis require additional training operations. Taking the sub-trellis 62 ₁ for example, assume that the sub-trellis 62 ₁ includes steps 0 to L1, i.e. the length of the sub-trellis is L. The forward state metric α₀(m), where m=0 to M1, is associated with the initial condition of the entire turbo code block, and is generally known and need not be calculated. However, the backward state metric β_(L−1)(m), where m=1 to M1, needs to be obtained through the backward recursion of an extended trellis 64 _(1R) (having a length R) following the sub-trellis 62 ₁. Even though the backward state metric β_(L+R−1)(m) of the backward recursion of the extended trellis 64 _(1R) is possibly randomly guessed, the backward state metric β_(L+R−1)(m) nonetheless becomes quite reliable after the having undergone the backward recursion that the extended trellis 64 _(1R) provides. Similarly, the forward state metric α_(L)(m) of the sub-trellis 62 ₂ needs to be obtained through the forward recursion of an extended trellis 64 _(2F) prior to the sub-trellis 62 ₂; the backward state metric β_(2L−1)(m) of the sub-trellis 62 ₂ needs to be obtained through the backward recursion of an extended trellis 64 _(2R) following the sub-trellis 62 ₂. The backward and forward recursion in the extended trellis are the foregoing additional learning operations. Through the window technology, although all sub-trellises are allowed to be processed in a parallel manner to reduce the output latency, additional learning operations are required.

FIG. 5 shows a type of window decoding that eliminates the additional learning operation. Similarly, a trellis 70 is divided into a plurality of same-sized sub-trellises 72 ₁ to 72 ₄, each of which having a sub-trellis length L. In the decoding process, all of the sub-trellises 72 ₁ to 72 ₄ can similarly be processed in parallel. The 1^(st) half-iteration HI₁, and the 2^(nd) half-iteration HI₂ are collectively referred to as the 1^(st) iteration IT₁. The stake of each sub-trellis is an operation result of an adjacent sub-trellis of a previous iteration loop. For example, in the 3^(rd) half-iteration HI₃ in FIG. 5, the forward state metric α_(L)(m) of the starting step of the sub-trellis 72 ₂ is adopted from the forward state metric α_(L−1)(m) generated by the sub-trellis 72 ₁ and calculated according to equation (2) in the 1^(st) half-iteration HI₁. Similarly, in the 3^(rd) half-iteration HI₃, the backward state metric β_(2L−1)(m) of the ending step of the sub-trellis 72 ₂ is adopted from the backward state metric β_(2L)(m) generated by the sub-trellis 72 ₃ and calculated according to equation (3) in the 1^(st) half-iteration HI₁. In other words, in each iteration loop, in addition to decoding each of the parallel sub-trellises, the training operation is also at the same time performed, which is equivalently to preparing the information that the stake of the next iteration loop needs. Thus, the additional learning operations involved in FIG. 5 can be eliminated.

FIG. 6 shows parallel windowed decoding adopted according to an embodiment of the present invention. In addition to eliminating the additional learning operation, the embodiment further accelerates the converging speed of the iteration loop or reduces the bit error rate (BER). A trellis 80 in FIG. 6 is a circular trellis. That is, the condition of the last step of the trellis 80 is the same as that of the earliest step, and so the beginning and the end of the trellis 80 are connected to form a circle.

Similar to FIG. 5, in each half-iteration in the embodiment in FIG. 6, the trellis 80 is divided into a plurality of sub-trellises using a window having a fixed size. The sub-trellises have a same length L. In the embodiment, the block code length is K=4L. The trellis 80 is divided into four sub-trellises 821 ₁ to 821 ₄ in the 1^(st) half-iteration HI₁, divided into four sub-trellises 822 ₁ to 822 ₄ in the 2^(nd) half-iteration HI₂, divided into four sub-trellises 823 ₁ to 823 ₄ in the 3^(rd) half-iteration HI₃ using predetermined dividing lines 84 ₁ to 84 ₄, and so forth. In practice, each dividing line represents a specific step in the trellis 80. It should be noted that, after each iteration, the boundary of the sub-trellis is changed. For example, as the predetermined dividing lines 84 ₁, 84 ₂ . . . are in the sub-trellises 821 ₁, 821 ₂ . . . , i.e., the predetermined dividing lines are not aligned with the boundaries of the sub-trellises 821 ₁, 821 ₂ . . . , the boundaries of the sub-trellises 821 ₁, 821 ₂ . . . are not aligned with the boundaries of the sub-trellises 823 ₁, 823 ₂ . . . . For example, the sub-trellis 823 ₁ is a result of a rear part of the sub-trellis 821 ₄ connected to a front part of the sub-trellis 821 ₁. Preferably, the position of each predetermined dividing line is the middle point between an S step and an S+1 step prior to the boundaries of each sub-trellis. Therefore, the sub-trellis 823 ₂ is levelly shifted forward by S steps compared to the sub-trellis 821 ₂.

In each half-iteration, four SISO decoders can be applied to decode four sub-trellises in a parallel manner. In the decoding process, forward recursion and backward recursion are performed to generate extrinsic information. Each SISO decoder uses a maximum a posterior (MAP) algorithm to calculate soft output of each step. The MAP algorithm may be a log-MAP, MAP, max-log-MAP or constant-log-MAP algorithm.

The stake needed for decoding a sub-trellis is adopted directly from the calculated result of a previous iteration, as shown in FIG. 6. In the 3^(rd) half-iteration HI₃ in FIG. 6, the forward state metric α_(L−S)(m) of the starting step of the sub-trellis 823 ₂ may be duplicated directly from the forward state metric α_(L−S)(m) that is generated by the sub-trellis 821 ₁ in the 1^(st) half-iteration HI₁ and is in the step L−S after the predetermined dividing line 84 ₁. Similarly, the backward state metric β_(2L−S−1)(m) of the ending step of the sub-trellis 823 ₂ may be duplicated directly from the backward state metric β_(2L−S−1)(m) that is generated by the sub-trellis 821 ₂ in the 1^(st) half-iteration HI₁ and is in the step 2L−S−1 before the predetermined dividing line 84 ₂. In the 1^(st) half-iteration HI₁, the forward state metric α_(L−S)(m) and the backward state metric β_(2L−S−1)(m) need be especially recorded to readily serve as the stake required in the 3^(rd) half-iteration HI₃.

In FIG. 6, it is also shown that, in the 5^(th) half-iteration HI₅, the trellis 80 is divided into four sub-trellises by four predetermined dividing lines 86 ₁ to 86 ₄. In the 5^(th) half-iteration HI₅, the stake of each sub-trellis is adopted directly from the state metrics at two sides of the predetermined dividing lines 86 ₁ to 86 ₄ in the 3^(rd) half-iteration.

Similarly, although not shown in FIG. 6, the calculated result in the 2^(nd) half-iteration HI₂ may also be recorded to directly serve as the stake that each sub-trellis requires in corresponding steps in the 4^(th) half-iteration HI₄.

In FIG. 6, the stake is the result of the training operation of the previous iteration, and is entitled to a certain level of reliability. Taking the sub-trellis 823 ₂ for example, the forward state metric α_(L−S)(m) has undergone the learning operations from the step 0 to the step L−S in a forward direction of the sub-trellis 821 ₁, and the backward state metric β_(2L−S−1)(m) has undergone the learning operations from the step 2L−1 to the step 2L−S−1 in a reverse direction of the sub-trellis 821 ₂.

Compared to FIG. 5, without undergoing calculations of equation (2) and equation (3), the stake in FIG. 6 is duplicated directly from the state metric of the previous iteration, and calculation operations can be saved.

Compared to FIG. 5, FIG. 6 further reduces the BER. In FIG. 6, in the 1^(st) half-iteration HI₁, only α₁(m) and β_(K)(m) are specific. Thus, in the 1^(st) half-iteration HI₁, the extrinsic information generated by the sub-trellises 821 ₁ and 821 ₄ is more reliable than the extrinsic information generated by the sub-trellises 821 ₂ and 821 ₃. For example, the a priori information used for decoding the sub-trellis 823 ₂ may be divided into a front half and a rear half, which are mainly affected by the extrinsic information of the sub-trellises 821 ₁ and 821 ₂, respectively. For forward recursion, the front half of the a priori information of the sub-trellis 823 ₂, having undergone operations of almost the entire sub-trellis 821 ₁, provides a certain level of reliability. Similarly, for backward recursion, the rear half of the a priori information of the sub-trellis 823 ₂, having undergone operations of a section of the sub-trellis 821 ₁, also provides a certain level of reliability. In other words, in the 3^(rd) half-iteration HI₃, not only each sub-trellis has a more reliable stake that need not be again calculated, but also the a priori information obtained is more reliable. Compared to the embodiment in FIG. 6, in the embodiment in FIG. 5, dividing lines and positions of the sub-trellises are fixed, and so the associated a priori information is not assisted as the more reliable a priori information obtained in FIG. 6. Compared to the embodiment in FIG. 5, the embodiment in FIG. 6 reduces the BER. That is to say, the decoding in FIG. 6 is more robust. It should be noted that, the expression “dividing a trellis into a plurality of sub-trellises” is given for illustration purposes. In practice, data of one trellis may be stored as data of a plurality of non-overlapping sub-trellises. Alternatively, the decoding of the sub-trellises may be performed through determining a plurality of steps and starting to read data of a predetermined length (i.e., the sub-trellis length) from different steps.

FIG. 7 shows a decoding method of the present invention. In step 90, a trellis is divided into a plurality of sub-trellises, each having the same length. In step 92, a first record is utilized as a stake and a priori information L_(a1) is utilized as an input to decode the sub-trellises in a parallel manner to generate extrinsic information L_(e1). Such is one half-iteration. In the 1^(st) half-iteration of the 1^(st) iteration, the stake may be set as a predetermined fixed value. For example, all α and β serving as the stake are set to 0. In step 94, the first record is updated according to a forward state metric and a backward state metric at two adjacent steps of a predetermined dividing line in the sub-trellis. An interleaving process is performed on the extrinsic information L_(e1) to generate a priori information L. In step 96, a second record is utilized as the stake and the a priori information L_(a2) is utilized as an input to decode the sub-trellises in a parallel manner to generate extrinsic information L_(e2). Such is another half-iteration. Similarly, in the 2^(nd) half-iteration of the 1^(st) iteration, the stake may be set as a predetermined fixed value. For example, all α and β serving as the stake are set to 0. In step 98, the second record is updated according to a forward state metric and a backward state metric at two adjacent steps of a predetermined dividing line in the sub-trellis. An interleaving process is performed on the extrinsic information L_(e2) to generate a priori information L_(a1). At this point, one iteration loop is complete. In step 100, a next iteration is prepared, and the trellis is divided by predetermined lines to again generate a plurality of sub-trellises. The sub-trellises divided and generated in step 100 are divided and formed from old sub-trellises, and thus have different boundaries from the sub-trellises divided in step 90. Step 92 is performed after step 100 to perform another round of decoding on the trellis according to the newly divided sub-trellises.

While the invention has been described by way of example and in terms of the preferred embodiments, it is to be understood that the invention is not limited thereto. On the contrary, it is intended to cover various modifications and similar arrangements and procedures, and the scope of the appended claims therefore should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements and procedures. 

What is claimed is:
 1. A decoding method for a convolutionally coded signal of a communication system pre-storing recursion state metrics for decoding sub-trellises resulting in accelerating iteration loop convergence and reducing bit error rates, the convolutionally coded signal comprising a trellis with steps, the decoding method comprising: determining a plurality of first sub-trellises from the trellis, and determining a corresponding step for each of the first sub-trellises, each corresponding step represented by a corresponding dividing line in the trellis, each dividing line distinct from the boundaries of all the first sub-trellises; decoding the first sub-trellises to generate a plurality of state metrics; storing a first record containing the plurality of state metrics generated prior to and subsequent to the corresponding steps; determining a plurality of second sub-trellises from the trellis, the boundaries of each of the second sub-trellises being distinct and non-aligned with the boundaries of each of the first sub-trellises; and decoding the second sub-trellises by utilizing the first record as an initial condition of the second sub-trellises.
 2. The decoding method according to claim 1, wherein the step of determining the second sub-trellises from the trellis is performed according to the corresponding steps.
 3. The decoding method according to claim 1, wherein the step of decoding the first sub-trellises to generate the state metrics comprises: decoding the first sub-trellises by forward recursion to generate a plurality of forward state metrics; and decoding the first sub-trellises by backward recursion to generate a plurality of backward state metrics; wherein, each of the state metrics prior and subsequent to the corresponding steps comprises one of the forward state metrics and one of the backward state metrics.
 4. The decoding method according to claim 1, wherein each of the first sub-trellises has a first sub-trellis length, each of the second sub-trellises has a second sub-trellis length, and the first sub-trellis length is equal to the second sub-trellis length.
 5. The decoding method according to claim 1, wherein the step of decoding the first sub-trellises is decoding the first sub-trellises in a parallel manner.
 6. The decoding method according to claim 1, wherein the steps of decoding the first and second sub-trellises are based on a soft-in-soft-out (SISO) decoding method.
 7. The decoding method according to claim 1, wherein the step of decoding the first sub-trellises is a half-iteration of one iteration, and the step of decoding the second sub-trellises is a half-iteration of another iteration.
 8. The decoding method according to claim 1, wherein the plurality of second sub-trellises from the trellis are determined such that a given step is represented by a corresponding dividing line in the trellis that is distinct from the boundary of each first sub-trellis, and the first record contains both the plurality of state metrics generated prior to the given step and the plurality of state metrics generated subsequent to the given step.
 9. The decoding method according to claim 1, wherein the first record is updated according to a forward state metric and a backward state metric at a corresponding dividing line in the trellis for two adjacent steps in the first sub-trellis.
 10. A decoding method for a convolutionally coded signal of a communication system pre-storing recursion state metrics for decoding sub-trellises resulting in accelerating iteration loop convergence and reducing bit error rates, the convolutionally coded signal comprising a trellis, the decoding method comprising: determining a plurality of first sub-trellises from the trellis, wherein the first sub-trellises forms the trellis, the boundaries of all the first sub-trellises defined by a dividing line in the trellis corresponding to a given step; decoding the first sub-trellises; determining a plurality of second sub-trellises from the trellis, wherein the second sub-trellises forms the trellis, and boundaries of the second sub-trellises are non-aligned, distinct, and different from the boundaries of the first sub-trellises; and decoding the second sub-trellises.
 11. The decoding method according to claim 10, wherein the first sub-trellises are non-overlapping.
 12. The decoding method according to claim 10, further comprising: when decoding the first sub-trellises, generating a plurality of state metrics for the first sub-trellises; and when decoding the second sub-trellises, utilizing the state metrics as initial conditions of the second sub-trellises.
 13. The decoding method according to claim 10, wherein the step of decoding the first sub-trellises comprises: decoding one of the first sub-trellises by forward recursion to generate a forward state metric, the forward state metric corresponding to a first step of the trellis; and decoding the one of the first sub-trellises by backward recursion to generate a backward state metric, the backward state metric corresponding to a second step of the trellis, the first and second steps being adjacent to each other, the second step being earlier than the first step; and the step of decoding the second sub-trellises comprises: utilizing the backward state metric as an initial condition for decoding one of the second sub-trellises; and utilizing the forward state metric as an initial condition of another of the second sub-trellises, the another of the second sub-trellises following the one of the second sub-trellis.
 14. The decoding method according to claim 10, wherein each of the first sub-trellises has a first sub-trellis length, each of the second sub-trellises has a second sub-trellis length, and the first sub-trellis length is equal to the second sub-trellis length.
 15. The decoding method according to claim 10, wherein the step of decoding the first sub-trellises is decoding the first sub-trellises in a parallel manner.
 16. The decoding method according to claim 10, wherein the first sub-trellises comprise a previous first sub-trellis and a next first sub-trellis, one of the second sub-trellises comprises a part of the previous first sub-trellis and a part of the next first sub-trellis, and the next first sub-trellis follows to the previous first sub-trellis.
 17. The decoding method according to claim 10, further comprising: providing a turbo decoder; wherein, the turbo decoder decodes the trellis twice in one iteration loop, and the steps of decoding the first sub-trellises and the step of decoding the second sub-trellises are from different iteration loops.
 18. The decoding method according to claim 10, wherein the step of decoding the first sub-trellises and the step of decoding the second sub-trellises calculate soft output for each step by utilizing a maximum a posteriori (MAP) algorithm, and the MAP algorithm is one of log-MAP, MAP, max-log-MAP and constant-log-MAP algorithms. 